/*

Copyright (c) 1991, 1998 The Open Group

Permission to use, copy, modify, distribute, and sell this software and its
documentation for any purpose is hereby granted without fee, provided that
the above copyright notice appear in all copies and that both that
copyright notice and this permission notice appear in supporting
documentation.

The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

Except as contained in this notice, the name of The Open Group shall not be
used in advertising or otherwise to promote the sale, use or other dealings
in this Software without prior written authorization from The Open Group.

*/

/* Constructs string definitions */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <unistd.h>

typedef struct _TableEnt {
    struct _TableEnt *next;
    char *left;
    char *right;
    size_t offset;
} TableEnt;

typedef struct _Table {
    struct _Table *next;
    TableEnt *tableent;
    TableEnt *tableentcurrent;
    TableEnt **tableenttail;
    char *name;
    size_t offset;
} Table;

typedef struct _File {
    struct _File *next;
    FILE *tmpl;
    char *name;
    Table *table;
    Table *tablecurrent;
    Table **tabletail;
} File;

static File *file = NULL;
static File *filecurrent = NULL;
static File **filetail = &file;
static char *conststr;
static char *prefixstr = NULL;
static char *featurestr = NULL;
static char *ctmplstr = NULL;
static char *fileprotstr;
static char *externrefstr;
static char *externdefstr;

#ifndef FALSE
#define FALSE 0
#define TRUE  !(FALSE)
#endif

static int solaris_abi_names = FALSE;

#define X_DEFAULT_ABI   0
#define X_ARRAYPER_ABI  1
#define X_INTEL_ABI     2
#define X_INTEL_ABI_BC  3
#define X_SPARC_ABI     4
#define X_FUNCTION_ABI  5

#define X_MAGIC_STRING "<<<STRING_TABLE_GOES_HERE>>>"

/* Wrapper for fopen()
 * Prepend filename with an includedir which can be specified on the
 * commandline. Needed to separate source and build directories.
 */
static char *includedir = NULL;
static FILE *
ifopen(const char *myfile, const char *mode)
{
#ifndef HAVE_ASPRINTF
    size_t len;
#endif
    char *buffer;
    FILE *ret;

    if (includedir == NULL)
        return fopen(myfile, mode);

#ifdef HAVE_ASPRINTF
    if (asprintf(&buffer, "%s/%s", includedir, myfile) == -1)
        return NULL;
#else
    len = strlen(myfile) + strlen(includedir) + 1;
    buffer = (char *) malloc(len + 1);
    if (buffer == NULL)
        return NULL;

    snprintf(buffer, len + 1, "%s/%s", includedir, myfile);
#endif

    ret = fopen(buffer, mode);

    free(buffer);
    return ret;
}

static void
WriteHeaderProlog(FILE * f, File * phile)
{
    Table *t;
    TableEnt *te;

    (void) fprintf(f, "#ifdef %s\n", featurestr);
    for (t = phile->table; t; t = t->next) {
        for (te = t->tableent; te; te = te->next) {
            if (strcmp(te->left, "RAtom") == 0) {
                (void) fprintf(f,
                               "#ifndef %s%s\n#define %s%s \"%s\"\n#endif\n",
                               prefixstr, te->left, prefixstr, te->left,
                               te->right);
            }
            else {
                (void) fprintf(f,
                               "#define %s%s \"%s\"\n",
                               prefixstr, te->left, te->right);
            }
        }
    }
    (void) fprintf(f, "%s", "#else\n");
}

static void
IntelABIWriteHeader(FILE * f, File * phile)
{
    Table *t;
    TableEnt *te;

    WriteHeaderProlog(f, phile);

    for (t = phile->table; t; t = t->next) {
        (void) fprintf(f, "%s %sConst char %s[];\n",
                       externrefstr, conststr ? conststr : fileprotstr,
                       t->name);
        for (te = t->tableent; te; te = te->next) {
            (void) fprintf(f,
                           "#ifndef %s%s\n#define %s%s ((String)&%s[%lu])\n#endif\n",
                           prefixstr, te->left, prefixstr, te->left, t->name,
                           (unsigned long) te->offset);
        }
    }

    (void) fprintf(f, "#endif /* %s */\n", featurestr);
}

static void
SPARCABIWriteHeader(FILE * f, File * phile)
{
    Table *t;
    TableEnt *te;

    for (t = phile->table; t; t = t->next) {
        for (te = t->tableent; te; te = te->next) {
            (void) fprintf(f, "#define %s%s \"%s\"\n",
                           prefixstr, te->left, te->right);
        }
    }
}

static void
FunctionWriteHeader(FILE * f, File * phile)
{
    Table *t;
    TableEnt *te;

    WriteHeaderProlog(f, phile);

    (void) fprintf(f, "%s %sConst char* %s();\n",
                   externrefstr, conststr ? conststr : fileprotstr,
                   phile->table->name);

    for (t = phile->table; t; t = t->next) {
        for (te = t->tableent; te; te = te->next) {
            (void) fprintf(f,
                           "#ifndef %s%s\n#define %s%s (%s(%lu))\n#endif\n",
                           prefixstr, te->left, prefixstr, te->left,
                           phile->table->name, (unsigned long) te->offset);
        }
    }

    (void) fprintf(f, "#endif /* %s */\n", featurestr);
}

static void
ArrayperWriteHeader(FILE * f, File * phile)
{
    Table *t;
    TableEnt *te;

    WriteHeaderProlog(f, phile);

    for (t = phile->table; t; t = t->next) {
        for (te = t->tableent; te; te = te->next) {
            (void) fprintf(f,
                           "#ifndef %s%s\n%s %sConst char %s%s[];\n#endif\n",
                           prefixstr, te->left,
                           externrefstr, conststr ? conststr : fileprotstr,
                           prefixstr, te->left);
        }
    }

    (void) fprintf(f, "#endif /* %s */\n", featurestr);
}

static void
DefaultWriteHeader(FILE * f, File * phile)
{
    Table *t;
    TableEnt *te;

    WriteHeaderProlog(f, phile);

    (void) fprintf(f, "%s %sConst char %s[];\n",
                   externrefstr, conststr ? conststr : fileprotstr,
                   phile->table->name);

    for (t = phile->table; t; t = t->next) {
        for (te = t->tableent; te; te = te->next) {
            (void) fprintf(f,
                           "#ifndef %s%s\n#define %s%s ((String)&%s[%lu])\n#endif\n",
                           prefixstr, te->left, prefixstr, te->left,
                           phile->table->name, (unsigned long) te->offset);
        }
    }

    (void) fprintf(f, "#endif /* %s */\n", featurestr);
}

static void
CopyTmplProlog(FILE * tmpl, FILE * f)
{
    char buf[1024];
    static const char *magic_string = X_MAGIC_STRING;
    size_t magic_string_len = strlen(magic_string);

    while (fgets(buf, sizeof buf, tmpl)) {
        if (strncmp(buf, magic_string, magic_string_len) == 0) {
            return;
        }
        (void) fputs(buf, f);
    }
}

static void
CopyTmplEpilog(FILE * tmpl, FILE * f)
{
    char buf[1024];

    while (fgets(buf, sizeof buf, tmpl))
        (void) fputs(buf, f);
}

static const char *abistring[] = {
    "Default", "Array per string", "Intel", "Intel BC", "SPARC", "Function"
};

static void
WriteHeader(char *tagline, File * phile, int abi)
{
    FILE *f;
    char *tmp;

    static void (*headerproc[]) (FILE * f, File * phile) = {
    DefaultWriteHeader, ArrayperWriteHeader,
            IntelABIWriteHeader, IntelABIWriteHeader,
            SPARCABIWriteHeader, FunctionWriteHeader};

    if ((f = fopen(phile->name, "w+")) == NULL)
        exit(1);

    if (phile->tmpl)
        CopyTmplProlog(phile->tmpl, f);

    (void) fprintf(f,
                   "%s\n%s\n/* %s ABI version -- Do not edit */\n",
                   "/* $Xorg: makestrs.c,v 1.6 2001/02/09 02:03:17 xorgcvs Exp $ */",
                   "/* This file is automatically generated. */",
                   abistring[abi]);

    if (tagline)
        (void) fprintf(f, "/* %s */\n\n", tagline);

    /* do the right thing for Motif, i.e. avoid _XmXmStrDefs_h_ */
    if (strcmp(prefixstr, "Xm") == 0) {
#ifdef HAVE_ASPRINTF
        if (asprintf(&fileprotstr, "_%s_", phile->name) == -1)
            exit(1);
#else
        if ((fileprotstr = malloc(strlen(phile->name) + 3)) == NULL)
            exit(1);
        (void) sprintf(fileprotstr, "_%s_", phile->name);
#endif
    }
    else {
#ifdef HAVE_ASPRINTF
        if (asprintf(&fileprotstr, "_%s%s_", prefixstr, phile->name) == -1)
            exit(1);
#else
        if ((fileprotstr =
             malloc(strlen(phile->name) + strlen(prefixstr) + 3)) == NULL)
            exit(1);
        (void) sprintf(fileprotstr, "_%s%s_", prefixstr, phile->name);
#endif
    }

    for (tmp = fileprotstr; *tmp; tmp++)
        if (*tmp == '.')
            *tmp = '_';

    (*headerproc[abi]) (f, phile);

    if (phile->tmpl)
        CopyTmplEpilog(phile->tmpl, f);

    (void) free(fileprotstr);
    (void) fclose(phile->tmpl);
    (void) fclose(f);
}

static void
WriteSourceLine(TableEnt * te, int abi, int fudge)
{
    char *c;

    (void) abi;
    for (c = te->right; *c; c++)
        (void) printf("'%c',", *c);
    (void) printf("%c", '0');
    if (te->next || fudge)
        (void) printf("%c", ',');
    (void) printf("%s", "\n");
}

#define const_string "%s %sConst char %s[] = {\n"

static void
IntelABIWriteSource(int abi)
{
    File *phile;

    for (phile = file; phile; phile = phile->next) {
        Table *t;
        TableEnt *te;

        for (t = phile->table; t; t = t->next) {
            (void) printf(const_string, externdefstr,
                          conststr ? conststr : "", t->name);
            for (te = t->tableent; te; te = te->next) {
                WriteSourceLine(te, abi, 0);
            }
            (void) printf("%s\n\n", "};");
        }
    }
}

static void
IntelABIBCWriteSource(int abi)
{
    File *phile;

    for (phile = file; phile; phile = phile->next) {
        Table *t;
        TableEnt *te;

        (void) printf(const_string, externdefstr,
                      conststr ? conststr : "", phile->table->name);

        for (t = phile->table; t; t = t->next) {
            for (te = t->tableent; te; te = te->next) {
                WriteSourceLine(te, abi, t->next ? 1 : 0);
            }
        }
        (void) printf("%s\n\n", "};");

        if (phile->table->next) {
            (void) printf(const_string, externdefstr,
                          conststr ? conststr : "", phile->table->next->name);
            for (t = phile->table->next; t; t = t->next) {
                for (te = t->tableent; te; te = te->next) {
                    WriteSourceLine(te, abi, 0);
                }
            }
            (void) printf("%s\n\n", "};");
        }
    }
}

static void
FunctionWriteSource(int abi)
{
    File *phile;

    for (phile = file; phile; phile = phile->next) {
        Table *t;
        TableEnt *te;

        (void) printf("static %sConst char _%s[] = {\n",
                      conststr ? conststr : "", phile->table->name);

        for (t = phile->table; t; t = t->next) {
            for (te = t->tableent; te; te = te->next) {
                WriteSourceLine(te, abi, t->next ? 1 : 0);
            }
        }
        (void) printf("%s\n\n", "};");

        (void)
            printf
            ("%sConst char* %s(index)\n    int index;\n{\n    return &_%s[index];\n}\n\n",
             conststr ? conststr : "", phile->table->name, phile->table->name);
    }
}

static void
ArrayperWriteSource(int abi)
{
    File *phile;
    static int done_atom;

    (void) abi;
    for (phile = file; phile; phile = phile->next) {
        Table *t;
        TableEnt *te;

        for (t = phile->table; t; t = t->next) {
            for (te = t->tableent; te; te = te->next) {
                if (strcmp(te->left, "RAtom") == 0) {
                    if (done_atom)
                        return;
                    done_atom = 1;
                }
                (void) printf("%s %sConst char %s%s[] = \"%s\";\n",
                              externdefstr, conststr ? conststr : "",
                              prefixstr, te->left, te->right);
            }
        }
    }
}

static void
DefaultWriteSource(int abi)
{
    File *phile;

    for (phile = file; phile; phile = phile->next) {
        Table *t;
        TableEnt *te;

        (void) printf(const_string, externdefstr, conststr ? conststr : "",
                      phile->table->name);

        for (t = phile->table; t; t = t->next) {
            for (te = t->tableent; te; te = te->next) {
                WriteSourceLine(te, abi, t->next ? 1 : 0);
            }
        }
        (void) printf("%s\n\n", "};");
    }
}

static void
WriteSource(char *tagline, int abi)
{
    static void (*sourceproc[]) (int) = {
    DefaultWriteSource, ArrayperWriteSource,
            IntelABIWriteSource, IntelABIBCWriteSource,
            DefaultWriteSource, FunctionWriteSource};

    FILE *tmpl;

    if (ctmplstr) {
        tmpl = ifopen(ctmplstr, "r");

        if (tmpl)
            CopyTmplProlog(tmpl, stdout);
        else {
            (void) fprintf(stderr, "Expected template %s, not found\n",
                           ctmplstr);
            exit(1);
        }
    }
    else
        tmpl = NULL;

    (void) printf("/* *%s* */\n", "INDENT-OFF");
    (void) printf("%s\n%s\n/* %s ABI version -- Do not edit */\n",
                  "/* $Xorg: makestrs.c,v 1.6 2001/02/09 02:03:17 xorgcvs Exp $ */",
                  "/* This file is automatically generated. */",
                  abistring[abi]);

    if (tagline)
        (void) printf("/* %s */\n\n", tagline);

    (*sourceproc[abi]) (abi);

    if (tmpl) {
        CopyTmplEpilog(tmpl, stdout);
        fclose(tmpl);
    }
    (void) printf("/* *%s* */\n", "INDENT-ON");
}

static void
DoLine(char *buf)
{
#define X_NO_TOKEN 0
#define X_FILE_TOKEN 1
#define X_TABLE_TOKEN 2
#define X_PREFIX_TOKEN 3
#define X_FEATURE_TOKEN 4
#define X_EXTERNREF_TOKEN 5
#define X_EXTERNDEF_TOKEN 6
#define X_CTMPL_TOKEN 7
#define X_HTMPL_TOKEN 8
#define X_CONST_TOKEN 9

    int token;
    char lbuf[1024];
    static const char *file_str = "#file";
    static const char *table_str = "#table";
    static const char *prefix_str = "#prefix";
    static const char *feature_str = "#feature";
    static const char *externref_str = "#externref";
    static const char *externdef_str = "#externdef";
    static const char *ctmpl_str = "#ctmpl";
    static const char *htmpl_str = "#htmpl";
    static const char *const_str = "#const";

    if (strncmp(buf, file_str, strlen(file_str)) == 0)
        token = X_FILE_TOKEN;
    else if (strncmp(buf, table_str, strlen(table_str)) == 0)
        token = X_TABLE_TOKEN;
    else if (strncmp(buf, prefix_str, strlen(prefix_str)) == 0)
        token = X_PREFIX_TOKEN;
    else if (strncmp(buf, feature_str, strlen(feature_str)) == 0)
        token = X_FEATURE_TOKEN;
    else if (strncmp(buf, externref_str, strlen(externref_str)) == 0)
        token = X_EXTERNREF_TOKEN;
    else if (strncmp(buf, externdef_str, strlen(externdef_str)) == 0)
        token = X_EXTERNDEF_TOKEN;
    else if (strncmp(buf, ctmpl_str, strlen(ctmpl_str)) == 0)
        token = X_CTMPL_TOKEN;
    else if (strncmp(buf, htmpl_str, strlen(htmpl_str)) == 0)
        token = X_HTMPL_TOKEN;
    else if (strncmp(buf, const_str, strlen(const_str)) == 0)
        token = X_CONST_TOKEN;
    else
        token = X_NO_TOKEN;

    switch (token) {
    case X_FILE_TOKEN:
    {
        File *phile;

        if ((phile = (File *) malloc(sizeof(File))) == NULL)
            exit(1);
        if ((phile->name = strdup(buf + strlen(file_str) + 1)) == NULL)
            exit(1);
        phile->table = NULL;
        phile->tablecurrent = NULL;
        phile->tabletail = &phile->table;
        phile->next = NULL;
        phile->tmpl = NULL;

        *filetail = phile;
        filetail = &phile->next;
        filecurrent = phile;
    }
        break;
    case X_TABLE_TOKEN:
    {
        Table *table;

        if ((table = (Table *) malloc(sizeof(Table))) == NULL)
            exit(1);
        if ((table->name = strdup(buf + strlen(table_str) + 1)) == NULL)
            exit(1);
        if (solaris_abi_names) {
            if (strcmp(table->name, "XtStringsR6") == 0) {
                strcpy(table->name, "XtR6Strings");
            }
            else if (strcmp(table->name, "XtShellStringsR6") == 0) {
                strcpy(table->name, "XtR6ShellStrings");
            }
        }
        table->tableent = NULL;
        table->tableentcurrent = NULL;
        table->tableenttail = &table->tableent;
        table->next = NULL;
        table->offset = 0;

        *filecurrent->tabletail = table;
        filecurrent->tabletail = &table->next;
        filecurrent->tablecurrent = table;
    }
        break;
    case X_PREFIX_TOKEN:
        if ((prefixstr = strdup(buf + strlen(prefix_str) + 1)) == NULL)
            exit(1);
        break;
    case X_FEATURE_TOKEN:
        if ((featurestr = strdup(buf + strlen(feature_str) + 1)) == NULL)
            exit(1);
        break;
    case X_EXTERNREF_TOKEN:
        if ((externrefstr = strdup(buf + strlen(externref_str) + 1)) == NULL)
            exit(1);
        break;
    case X_EXTERNDEF_TOKEN:
        if ((externdefstr = strdup(buf + strlen(externdef_str) + 1)) == NULL)
            exit(1);
        break;
    case X_CTMPL_TOKEN:
        if ((ctmplstr = strdup(buf + strlen(ctmpl_str) + 1)) == NULL)
            exit(1);
        break;
    case X_HTMPL_TOKEN:
        if ((filecurrent->tmpl =
             ifopen(buf + strlen(htmpl_str) + 1, "r")) == NULL) {
            (void) fprintf(stderr, "Expected template %s, not found\n",
                           htmpl_str);
            exit(1);
        }
        break;
    case X_CONST_TOKEN:
        if ((conststr = strdup(buf + strlen(const_str) + 1)) == NULL)
            exit(1);
        break;
    default:
    {
        char *right;
        TableEnt *tableent;
        size_t llen;
        size_t rlen;
        size_t len;

        if ((right = strchr(buf, ' ')))
            *right++ = 0;
        else
            right = buf + 1;
        if (buf[0] == 'H') {
            snprintf(lbuf, sizeof(lbuf), "%s%s", prefixstr, right);
            right = lbuf;
        }

        llen = len = strlen(buf) + 1;
        rlen = strlen(right) + 1;
        if (right != buf + 1)
            len += rlen;
        tableent = (TableEnt *) calloc(sizeof(TableEnt) + len, 1);
        if (tableent == NULL)
            exit(1);
        tableent->left = (char *) (tableent + 1);
        strcpy(tableent->left, buf);
        if (llen != len) {
            tableent->right = tableent->left + llen;
            strcpy(tableent->right, right);
        }
        else {
            tableent->right = tableent->left + 1;
        }
        tableent->next = NULL;

        *filecurrent->tablecurrent->tableenttail = tableent;
        filecurrent->tablecurrent->tableenttail = &tableent->next;
        filecurrent->tablecurrent->tableentcurrent = tableent;
    }
        break;
    }
}

static void
IntelABIIndexEntries(File * myfile)
{
    Table *t;
    TableEnt *te;

    for (t = myfile->table; t; t = t->next) {
        for (te = t->tableent; te; te = te->next) {
            te->offset = t->offset;
            t->offset += strlen(te->right);
            t->offset++;
        }
    }
}

static void
DefaultIndexEntries(File * myfile)
{
    Table *t;
    TableEnt *te;
    size_t offset = 0;

    for (t = myfile->table; t; t = t->next) {
        for (te = t->tableent; te; te = te->next) {
            te->offset = offset;
            offset += strlen(te->right);
            offset++;
        }
    }
}

static void
IndexEntries(File * myfile, int abi)
{
    switch (abi) {
    case X_SPARC_ABI:
        break;
    case X_INTEL_ABI:
    case X_INTEL_ABI_BC:
        IntelABIIndexEntries(myfile);
        break;
    default:
        DefaultIndexEntries(myfile);
        break;
    }
}

static char *
DoComment(char *line)
{
    char *tag;
    char *eol;
    char *ret;
    size_t len;

    /* assume that the first line with two '$' in it is the RCS tag line */
    if ((tag = strchr(line, '$')) == NULL)
        return NULL;
    if ((eol = strchr(tag + 1, '$')) == NULL)
        return NULL;
    len = (size_t) (eol - tag);
    if ((ret = malloc(len)) == NULL)
        exit(1);
    (void) strncpy(ret, tag + 1, len - 1);
    ret[len - 2] = 0;
    return ret;
}

int
main(int argc, char *argv[])
{
    size_t len;
    char *tagline = NULL;
    File *phile;
    FILE *f;
    char buf[1024];
    int abi =
#ifndef ARRAYPERSTR
        X_DEFAULT_ABI;
#else
        X_ARRAYPER_ABI;
#endif

    f = stdin;
    if (argc > 1) {
        int i;

        for (i = 1; i < argc; i++) {
            if (strcmp(argv[i], "-f") == 0) {
                if (++i < argc)
                    f = fopen(argv[i], "r");
                else
                    return 1;
            }
            if (strcmp(argv[i], "-i") == 0) {
                if (++i < argc) {
                    includedir = argv[i];
                }
                else {
                    if (f != 0 && f != stdin)
                        fclose(f);
                    return 1;
                }
            }
            if (strcmp(argv[i], "-sparcabi") == 0)
                abi = X_SPARC_ABI;
            if (strcmp(argv[i], "-intelabi") == 0)
                abi = X_INTEL_ABI;
            if (strcmp(argv[i], "-functionabi") == 0)
                abi = X_FUNCTION_ABI;
            if (strcmp(argv[i], "-earlyR6bc") == 0 && abi == X_INTEL_ABI)
                abi = X_INTEL_ABI_BC;
            if (strcmp(argv[i], "-arrayperabi") == 0)
                abi = X_ARRAYPER_ABI;
#ifdef ARRAYPERSTR
            if (strcmp(argv[i], "-defaultabi") == 0)
                abi = X_DEFAULT_ABI;
#endif
            if (strcmp(argv[i], "-solarisabinames") == 0)
                solaris_abi_names = TRUE;
        }
    }

    if (f == NULL)
        return 1;
    while (fgets(buf, sizeof buf, f)) {
        if (!buf[0] || buf[0] == '\n')
            continue;
        if (buf[0] == '!') {
            if (tagline)
                continue;
            tagline = DoComment(buf);
            continue;
        }
        if (buf[(len = strlen(buf) - 1)] == '\n')
            buf[len] = '\0';
        DoLine(buf);
    }
    for (phile = file; phile; phile = phile->next) {
        if (abi != X_ARRAYPER_ABI)
            IndexEntries(phile, abi);
        WriteHeader(tagline, phile, abi);
    }
    WriteSource(tagline, abi);
    return 0;
}
